home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / recio212.zip / testcog.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-30  |  11.0 KB  |  323 lines
  1. /* testcog.c - tests column delimited get functions */
  2. /* recio version 2.12, release January 29, 1995 */
  3. /* Copyright (C) 1994-1995, William Pierpoint */
  4.  
  5. #include <ctype.h>
  6. #include <errno.h>
  7. #include <limits.h>
  8. #include <float.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <time.h>
  13.  
  14. #include "recio.h"
  15.  
  16. /* errors normally to stderr; but for test purposes, stdout */
  17. #define errout  stdout
  18.  
  19. /****************************************************************************/
  20. void                         /* return nothing                              */
  21.     rfixnumber(              /* fix number                                  */
  22.         REC *rp,             /* record pointer                              */
  23.         int  errnum,         /* error number                                */
  24.         void (*rfix)(REC *)) /* rfix function pointer                       */
  25. /****************************************************************************/
  26. {
  27.   switch (errnum) {
  28.   case R_EMISDAT:
  29.     fprintf(errout, "...substituting zero\n");
  30.     rsetfldstr(rp, "0");
  31.     break;
  32.   case R_EINVDAT:
  33.   case R_ERANGE:
  34.     fprintf(errout, "...substituting best guess\n");
  35.     rfix(rp);
  36.     break;
  37.   }
  38. }
  39.  
  40. /****************************************************************************/
  41. void                         /* return nothing                              */
  42.     rfixchar(                /* fix character                               */
  43.         REC *rp,             /* record pointer                              */
  44.         int  errnum,         /* error number                                */
  45.         void (*rfix)(REC *)) /* rfix function pointer                       */
  46. /****************************************************************************/
  47. {
  48.   switch (errnum) {
  49.   case R_EMISDAT:
  50.     fprintf(errout, "...substituting the letter N\n");
  51.     rsetfldstr(rp, "N");
  52.     break;
  53.   case R_EINVDAT:
  54.     fprintf(errout, "...substituting best guess\n");
  55.     rfix(rp);
  56.     break;
  57.   }
  58. }
  59.  
  60. /****************************************************************************/
  61. void                         /* return nothing                              */
  62.     rfixtime(                /* fix time                                   */
  63.         REC *rp,             /* record pointer                              */
  64.         int  errnum,         /* error number                                */
  65.         void (*rfix)(REC *)) /* rfix function pointer                       */
  66. /****************************************************************************/
  67. {
  68.   switch (errnum) {
  69.   case R_EMISDAT:
  70.     fprintf(errout, "...substituting 1/1/70 00:00:00\n");
  71.     rsetfldstr(rp, "1/1/70 0:0:0");
  72.     break;
  73.   case R_EINVDAT:
  74.   case R_ERANGE:
  75.     fprintf(errout, "...substituting best guess\n");
  76.     rfix(rp);
  77.     break;
  78.   }
  79. }
  80.  
  81. /****************************************************************************/
  82. void                         /* returns nothing                             */
  83.     rwarnfn(                 /* recio callback warning function             */
  84.         REC *rp)             /* record pointer                              */
  85. /****************************************************************************/
  86. {
  87.   if (risvalid(rp)) {
  88.     switch (rwarning(rp)) {
  89.     case R_WNOREG:   /* atexit() full */
  90.       fprintf (errout, "WARNING %s\n", rwarnstr(rp));
  91.       break;
  92.     case R_WEMPSTR:  /* empty data string */
  93.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  94.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  95.       break;
  96.     }
  97.   }
  98. }
  99.  
  100. /****************************************************************************/
  101. void                         /* returns nothing                             */
  102.      errnofn(                /* errno callback error function               */
  103.         void)                /* no parameters                               */
  104. /****************************************************************************/
  105. {
  106.   switch (errno) {
  107.  
  108.   /* non-fatal errors */
  109.   case EACCES:
  110.   case EMFILE:
  111.     fprintf(errout, "ERROR: %s\n", strerror(errno));
  112.     break;
  113.  
  114.   /* fatal errors (EINVAL, ENOMEM) */
  115.   default:
  116.     fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  117.     abort();
  118.     break;
  119.   }
  120. }
  121.  
  122. /****************************************************************************/
  123. void                         /* returns nothing                             */
  124.     rerrfn(                  /* recio callback error function               */
  125.         REC *rp)             /* record pointer                              */
  126. /****************************************************************************/
  127. {
  128.   int errnum;       /* error number */
  129.  
  130.   if (risvalid(rp)) {
  131.   
  132.     /* if reof indicator set */
  133.     if (reof(rp)) { 
  134.       fprintf(errout, "ERROR reading %s: "
  135.        "tried to read past end of file\n", rnames(rp));
  136.     
  137.     /* else rerror indicator set */
  138.     } else {
  139.  
  140.       /* determine cause of error */
  141.       errnum = rerror(rp);
  142.       switch (errnum) {
  143.  
  144.       /* data errors */
  145.       case R_ERANGE:   /* data out of range */
  146.       case R_EINVDAT:  /* invalid data */
  147.       case R_EMISDAT:  /* missing data */
  148.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  149.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  150.             
  151.         /* determine context */
  152.         switch (rcxtno(rp)) {
  153.         case RECIN:
  154.           
  155.           /* determine field */
  156.           switch (rfldno(rp)) {
  157.           case 1:  /* the integer field i */
  158.             rfixnumber(rp, errnum, rfixi);
  159.             break;
  160.           
  161.           case 2:  /* the unsigned integer field ui */
  162.             rfixnumber(rp, errnum, rfixui);
  163.             break;
  164.  
  165.            case 3:  /* the long field l */
  166.             rfixnumber(rp, errnum, rfixl);
  167.             break;
  168.  
  169.            case 4:  /* the unsigned long field ul */
  170.             rfixnumber(rp, errnum, rfixul);
  171.             break;
  172.  
  173.            case 5:  /* the float field f */
  174.             rfixnumber(rp, errnum, rfixf);
  175.             break;
  176.  
  177.             case 6:  /* the double field d */
  178.             rfixnumber(rp, errnum, rfixd);
  179.             break;
  180.           
  181.           case 7: /* the character field ch */
  182.             rfixchar(rp, errnum, rfixc);
  183.             break;
  184.             
  185.           case 9: /* the time field t */
  186.             rfixtime(rp, errnum, rfixc);
  187.             break;
  188.  
  189.           default: /* programming error - no case for field */
  190.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  191.              rnames(rp), rfldno(rp));
  192.             break;
  193.           }
  194.           break;
  195.         
  196.         default:  /* programming error - missing context number */
  197.           fprintf(errout, "FATAL ERROR %s -- missing context number\n", 
  198.            rnames(rp));
  199.           abort();
  200.           break;
  201.         }
  202.         break;
  203.         
  204.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  205.       default:
  206.         fprintf(errout, "FATAL ERROR %s -- %s\n", rnames(rp), rerrstr(rp));
  207.         abort();
  208.         break;
  209.       }
  210.     }
  211.   
  212.   /* invalid record pointer */
  213.   } else {
  214.     errnofn();
  215.   }
  216. }
  217.  
  218. /****************************************************************************/
  219. void putcolnumbers(void)
  220. /****************************************************************************/
  221. {
  222. puts("         1         2         3         4         5         6         7");
  223. puts("1234567890123456789012345678901234567890123456789012345678901234567890123456789");
  224. }
  225.  
  226. /****************************************************************************
  227. main
  228. *****************************************************************************/
  229. #include <io.h>
  230.  
  231. int main()
  232. {
  233.   int i;                        /* integer field */
  234.   unsigned int ui;              /* unsigned integer field */
  235.   long l;                       /* long field */
  236.   unsigned long ul;             /* unsigned long field */
  237.   float f;                      /* float field */
  238.   double d;                     /* double field */
  239.   int ch;                       /* character field */
  240.   char *str = NULL;             /* string field */
  241.   time_t t;                     /* time field */
  242.   
  243.   /* install error and warning functions */
  244.   rinit(rerrfn, rwarnfn);
  245.   
  246.   /* set time format */
  247.   rsettmfmt(recin,  "%m/%d/%y");
  248.   rsettmfmt(recout, "%m/%d/%y");
  249.   
  250.   /* set recout to ignore field and text delimiters */
  251.   rsetfldch(recout, '\0');
  252.   rsettxtch(recout, '\0');
  253.   
  254.   /* set beginning column number to 1 */
  255.   rsetbegcolno(recin, 1);
  256.   
  257.   /* if input not redirected */
  258.   if (isatty(fileno(stdin))) {
  259.     /* print instructions */
  260.     puts("TESTCOG version 2.12 Copyright (C) 1994-1995, William Pierpoint");
  261.     puts("Tests recio column delimited get functions.");
  262.     puts("It reads eight fields from the console.\n");
  263.     puts("Field type           Columns");
  264.     puts("----------------    ---------");
  265.     puts("Integer............  1 to  5");
  266.     puts("Unsigned Integer...  6 to 10");
  267.     puts("Long............... 11 to 20");
  268.     puts("Unsigned Long...... 21 to 30");
  269.     puts("Float.............. 31 to 40");
  270.     puts("Double............. 41 to 50");
  271.     puts("Character..........    51   ");
  272.     puts("String............. 52 to 70");
  273.     puts("Time............... 71 to 79");
  274.     puts("\nPress Ctrl-Z followed by the Enter key to exit program.");
  275.     puts("You may begin now.\n");
  276.   }
  277.   
  278.   /* loop through input */
  279.   while (rgetrec(recin)) {
  280.  
  281.     putcolnumbers();
  282.    
  283.     /* if input redirected, echo record contents */
  284.     if (!isatty(fileno(stdin))) puts(rrecs(recin));
  285.  
  286.     /* parse record */
  287.     i   = rcgeti(recin,   1,  5);
  288.     ui  = rcgetui(recin,  6, 10);
  289.     l   = rcgetl(recin,  11, 20);
  290.     ul  = rcgetul(recin, 21, 30);
  291.     f   = rcgetf(recin,  31, 40);
  292.     d   = rcgetd(recin,  41, 50);
  293.     ch  = rcgetc(recin,  51);
  294.     scpys(str, rcgets(recin, 52, 70));
  295.     t   = rcgett(recin, 71, 79);
  296.  
  297.     /* print results */
  298.     puts("");
  299.     rputs(recout, "         Integer field: "); rputi(recout, i);   puts("");
  300.     rputs(recout, "Unsigned Integer field: "); rputui(recout, ui); puts("");
  301.     rputs(recout, "            Long field: "); rputl(recout, l);   puts("");
  302.     rputs(recout, "   Unsigned Long field: "); rputul(recout, ul); puts("");
  303.     rputs(recout, "           Float field: "); rputf(recout, f);   puts("");
  304.     rputs(recout, "          Double field: "); rputd(recout, d);   puts("");
  305.     rputs(recout, "       Character field: "); rputc(recout, ch);  puts("");
  306.     rputs(recout, "          String field: "); rputs(recout, str); puts("");
  307.     rputs(recout, "            Time field: "); rputt(recout, t);   puts("");
  308.     rputrec(recout);
  309.     puts("");
  310.   }
  311.   
  312.   /* free dynamic string fields */
  313.   free (str);
  314.   
  315.   /* check stream for error */
  316.   if (rerror(recin)) { 
  317.     fprintf(errout, "ERROR reading %s: %s\n", 
  318.      rnames(recin), rerrstr(recin));
  319.     exit (EXIT_FAILURE);
  320.   }
  321.   return EXIT_SUCCESS;
  322. }
  323.